package space.cloaking.looping;

import javax.annotation.Nonnull;

public interface ILoopQueue {

    /**
     * 在 LoopQueue 中添加一个事件，线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean post(@Nonnull LoopEventV event);

    /**
     * 在 LoopQueue 中添加一个事件，线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T> boolean post(@Nonnull LoopEvent1Arg<T> event, T arg);

    /**
     * 在 LoopQueue 中添加一个事件，线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2> boolean post(@Nonnull LoopEvent2Arg<T1, T2> event, T1 arg1, T2 arg2);

    /**
     * 在 LoopQueue 中添加一个事件，线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3> boolean post(@Nonnull LoopEvent3Arg<T1, T2, T3> event,
                              T1 arg1, T2 arg2, T3 arg3);

    /**
     * 在 LoopQueue 中添加一个事件，线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4> boolean post(@Nonnull LoopEvent4Arg<T1, T2, T3, T4> event,
                                  T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    /**
     * 在 LoopQueue 中添加一个事件，线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4, T5> boolean post(@Nonnull LoopEvent5Arg<T1, T2, T3, T4, T5> event,
                                      T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /**
     * 在 LoopQueue 中添加一个事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean postUnsafe(@Nonnull LoopEventV event);

    /**
     * 在 LoopQueue 中添加一个事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T> boolean postUnsafe(@Nonnull LoopEvent1Arg<T> event, T arg);

    /**
     * 在 LoopQueue 中添加一个事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2> boolean postUnsafe(@Nonnull LoopEvent2Arg<T1, T2> event, T1 arg1, T2 arg2);

    /**
     * 在 LoopQueue 中添加一个事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3> boolean postUnsafe(@Nonnull LoopEvent3Arg<T1, T2, T3> event,
                                           T1 arg1, T2 arg2, T3 arg3);

    /**
     * 在 LoopQueue 中添加一个事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4> boolean postUnsafe(@Nonnull LoopEvent4Arg<T1, T2, T3, T4> event,
                                               T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    /**
     * 在 LoopQueue 中添加一个事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4, T5> boolean postUnsafe(@Nonnull LoopEvent5Arg<T1, T2, T3, T4, T5> event,
                                            T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程安全的.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 post 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean postDelay(long millis, @Nonnull LoopEventV event);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程安全的.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 post 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T> boolean postDelay(long millis, @Nonnull LoopEvent1Arg<T> event, T arg);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程安全的.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 post 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2> boolean postDelay(long millis, @Nonnull LoopEvent2Arg<T1, T2> event,
                               T1 arg1, T2 arg2);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程安全的.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 post 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3> boolean postDelay(long millis, @Nonnull LoopEvent3Arg<T1, T2, T3> event,
                                   T1 arg1, T2 arg2, T3 arg3);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程安全的.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 post 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4> boolean postDelay(long millis, @Nonnull LoopEvent4Arg<T1, T2, T3, T4> event,
                                       T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程安全的.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 post 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4, T5> boolean postDelay(long millis, @Nonnull LoopEvent5Arg<T1, T2, T3, T4, T5> event,
                                           T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 postUnsafe 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean postDelayUnsafe(long millis, @Nonnull LoopEventV event);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 postUnsafe 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T> boolean postDelayUnsafe(long millis, @Nonnull LoopEvent1Arg<T> event, T arg);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 postUnsafe 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2> boolean postDelayUnsafe(long millis, @Nonnull LoopEvent2Arg<T1, T2> event,
                                     T1 arg1, T2 arg2);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 postUnsafe 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3> boolean postDelayUnsafe(long millis, @Nonnull LoopEvent3Arg<T1, T2, T3> event,
                                         T1 arg1, T2 arg2, T3 arg3);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 postUnsafe 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4> boolean postDelayUnsafe(long millis, @Nonnull LoopEvent4Arg<T1, T2, T3, T4> event,
                                             T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    /**
     * 在 LoopQueue 中添加一个有延时的事件，线程不安全的，只能本线程调用.
     * <p/>
     *
     * @param millis 延迟执行的时间, 单位 milliseconds， 传 0 等于 postUnsafe 系列方法
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4, T5> boolean postDelayUnsafe(long millis, @Nonnull LoopEvent5Arg<T1, T2, T3, T4, T5> event,
                                                 T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean postAtTime(long timeInMillis, @Nonnull LoopEventV event);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T> boolean postAtTime(long timeInMillis, @Nonnull LoopEvent1Arg<T> event, T arg);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2> boolean postAtTime(long timeInMillis, @Nonnull LoopEvent2Arg<T1, T2> event,
                                T1 arg1, T2 arg2);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3> boolean postAtTime(long timeInMillis, @Nonnull LoopEvent3Arg<T1, T2, T3> event,
                                    T1 arg1, T2 arg2, T3 arg3);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4> boolean postAtTime(long timeInMillis, @Nonnull LoopEvent4Arg<T1, T2, T3, T4> event,
                                        T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程安全的.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4, T5> boolean postAtTime(long timeInMillis, @Nonnull LoopEvent5Arg<T1, T2, T3, T4, T5> event,
                                            T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean postAtTimeUnsafe(long timeInMillis, @Nonnull LoopEventV event);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T> boolean postAtTimeUnsafe(long timeInMillis, @Nonnull LoopEvent1Arg<T> event, T arg);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2> boolean postAtTimeUnsafe(long timeInMillis, @Nonnull LoopEvent2Arg<T1, T2> event,
                                      T1 arg1, T2 arg2);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3> boolean postAtTimeUnsafe(long timeInMillis, @Nonnull LoopEvent3Arg<T1, T2, T3> event,
                                          T1 arg1, T2 arg2, T3 arg3);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4> boolean postAtTimeUnsafe(long timeInMillis, @Nonnull LoopEvent4Arg<T1, T2, T3, T4> event,
                                              T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    /**
     * 在 LoopQueue 中添加一个指定事件发生的事件，基于时基 {@link System#currentTimeMillis()}，
     * 线程不安全的，只能本线程调用.
     * <p/>
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4, T5> boolean postAtTimeUnsafe(long timeInMillis, @Nonnull LoopEvent5Arg<T1, T2, T3, T4, T5> event,
                                                  T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /**
     * 在 LoopQueue 中添加一个事件，并等待事件执行完成后再返回
     * <p/>
     *
     * 这个方法不能再本线程调用，否则会锁死.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean postWait(@Nonnull LoopEventV event);

    /**
     * 在 LoopQueue 中添加一个事件，并等待事件执行完成后再返回
     * <p/>
     *
     * 这个方法不能再本线程调用，否则会锁死.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T> boolean postWait(@Nonnull LoopEvent1Arg<T> event, T arg);

    /**
     * 在 LoopQueue 中添加一个事件，并等待事件执行完成后再返回
     * <p/>
     *
     * 这个方法不能再本线程调用，否则会锁死.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2> boolean postWait(@Nonnull LoopEvent2Arg<T1, T2> event,
                              T1 arg1, T2 arg2);

    /**
     * 在 LoopQueue 中添加一个事件，并等待事件执行完成后再返回
     * <p/>
     *
     * 这个方法不能再本线程调用，否则会锁死.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3> boolean postWait(@Nonnull LoopEvent3Arg<T1, T2, T3> event,
                                  T1 arg1, T2 arg2, T3 arg3);

    /**
     * 在 LoopQueue 中添加一个事件，并等待事件执行完成后再返回
     * <p/>
     *
     * 这个方法不能再本线程调用，否则会锁死.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4> boolean postWait(@Nonnull LoopEvent4Arg<T1, T2, T3, T4> event,
                                      T1 arg1, T2 arg2, T3 arg3, T4 arg4);

    /**
     * 在 LoopQueue 中添加一个事件，并等待事件执行完成后再返回
     * <p/>
     *
     * 这个方法不能再本线程调用，否则会锁死.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    <T1, T2, T3, T4, T5> boolean postWait(@Nonnull LoopEvent5Arg<T1, T2, T3, T4, T5> event,
                                          T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /**
     * 移除添加的某个事件， 多次添加同一个的会全部移除，线程安全的.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean remove(@Nonnull LoopEvent event);

    /**
     * 移除添加的某个事件， 多次添加同一个的会全部移除，线程不安全的，只能本线程调用.
     * 注意这个方法无法移除在异步队列中的事件，所以仅在确认某事件在本线程下添加时才可以
     * 用这个方法移除.
     *
     * @return true 如果成功， 否则为 LoopQueue 正在关闭或已关闭或未启动导致失败
     */
    boolean removeUnsafe(LoopEvent event);
}
